package com.deyang.mycommon.ui.activity.study;

import android.os.Bundle;
import android.support.annotation.NonNull;
import android.view.View;

import com.deyang.mycommon.R;
import com.deyang.mycommon.ui.baseui.BaseActivity;
import com.deyang.mycommon.util.Logger;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.TimeUnit;

import butterknife.ButterKnife;
import butterknife.OnClick;
import rx.Observable;
import rx.Subscriber;
import rx.android.schedulers.AndroidSchedulers;
import rx.functions.Action1;
import rx.functions.Func0;

/**
 * @author wangdyang
 * @createDate 2018年7月28日09:27:25
 * @desc RxJava 操作符篇        observable 的创建 不推荐使用 create 因为常常因为规范问题 引发错误，  比如判断是否取消订阅、是否使用oncomplete操作符结束等
 */
public class RxJavaOperatorActivity extends BaseActivity {

    Observable<Long> justObservable = getJust();
    Observable<Long> deferObservable = getDefer();

    @Override
    protected void initView(Bundle savedInstanceState) {
        setContentView(R.layout.activity_rx_java_operator);
        ButterKnife.bind(this);
    }

    @Override
    protected void processLogic(Bundle savedInstanceState) {
        //deferAndJust();
    }


    @OnClick({
            R.id.btn_range,
            R.id.btn_defer_just,
            R.id.btn_from,
            R.id.btn_interval,
            R.id.btn_repeat_timer,
    })
    @Override
    public void onClick(View v) {
        super.onClick(v);
        switch (v.getId()) {
            case R.id.btn_range:
                range();
                //deferAndJust();
                break;
            case R.id.btn_defer_just:
                deferAndJust();
                break;
            case R.id.btn_from:
                rxFrom();
                break;
            case R.id.btn_interval:
                rxInterval();
                break;
            case R.id.btn_repeat_timer:
                rxRepeatTimer();
                break;
        }
    }

    /**
     * Repeat 重复发送
     * Timer 指定时间后 发送数字0
     */
    private void rxRepeatTimer() {
        Observable.just(1, 2, 3).repeat(3).subscribe(new Action1<Integer>() {
            @Override
            public void call(Integer integer) {
                Logger.e(TAG, "repeat:" + integer);
            }
        });

        Observable.timer(10, TimeUnit.SECONDS)
                .subscribe(new Action1<Long>() {
                    @Override
                    public void call(Long aLong) {
                        Logger.e(TAG, "timer:" + aLong);
                    }
                });
    }

    /**
     * 间隔 时间 操作符   注意线程切换
     * 从0开始
     */
    private void rxInterval() {
        //  参数 间隔、单位
        Observable.interval(1, TimeUnit.SECONDS)
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Subscriber<Long>() {
                    @Override
                    public void onCompleted() {
                        Logger.e(TAG, "rxInterval onCompleted");
                    }

                    @Override
                    public void onError(Throwable e) {
                        Logger.e(TAG, "rxInterval e:" + e.getMessage());
                    }

                    @Override
                    public void onNext(Long aLong) {
                        Logger.e(TAG, "rxInterval onNext:" + aLong);
                        if (aLong > 30) {
                            //取消订阅
                            unsubscribe();
                        }
                    }
                });
    }

    /**
     * from 操作符 特点 和just类似，可以接收任何对象、数组      竟然不能接收int 等基本数据类型
     * 不同于 just 接收数组、list时 可将数据依次返回
     * 可以理解为遍历
     */
    private void rxFrom() {
        Integer[] ints = {1, 2, 3, 4, 5};
        List<Integer> integerList = new ArrayList<>();
        for (int i = 0; i < ints.length; i++) {
            integerList.add(ints[i]);
        }

        Observable.from(ints)
                .subscribe(new Action1<Integer>() {
                    @Override
                    public void call(Integer integer) {
                        Logger.e(TAG, "from ints:" + integer);
                    }
                });
        Observable.from(integerList)
                .subscribe(new Action1<Integer>() {
                    @Override
                    public void call(Integer integer) {
                        Logger.e(TAG, "from integerList:" + integer);
                    }
                });
    }

    /**
     * defer 操作符 只有当 有subscriber订阅的时候 才会创建 这样保证了每次数据都是新的
     * Just  操作符 接收一个对象（Integer string。。。可以是任何对象）  输出 被观察者Observable       应该会常用到
     */
    private void deferAndJust() {
        justObservable.subscribe(new Action1<Long>() {
            @Override
            public void call(Long aLong) {
                Logger.e(TAG, "justObservable:" + aLong);
            }
        });

        deferObservable.subscribe(new Action1<Long>() {
            @Override
            public void call(Long aLong) {
                Logger.e(TAG, "deferObservable:" + aLong);
            }
        });
    }

    @NonNull
    private Observable<Long> getDefer() {
        return Observable.defer(new Func0<Observable<Long>>() {
            @Override
            public Observable<Long> call() {
                return getJust();
            }
        });
    }

    @NonNull
    private Observable<Long> getJust() {
        //传入一个对象 返回被观察者
        return Observable.just(System.currentTimeMillis());
    }

    /**
     * range 操作符  发送 范围数据   注意参数
     */
    private void range() {
        //发送  10+5-1  的数据
        Observable.range(10, 5)
                .subscribe(new Action1<Integer>() {
                    @Override
                    public void call(Integer integer) {
                        Logger.i(TAG, "range integer:" + integer);
                    }
                });
    }

}
